/** axios封装
 * 请求拦截、响应拦截、错误统一处理
 */
import axios from "axios";
import QS from "qs";
import { ElMessage } from "element-plus";

let baseURL = "";

// 环境的切换
if (process.env.NODE_ENV == "development") {
  baseURL = "/api";
} else if (process.env.NODE_ENV == "debug") {
  baseURL = "";
} else if (process.env.NODE_ENV == "production") {
  baseURL = "http://192.168.10.10:8091";
}

axios.defaults.baseURL = baseURL;
// 请求超时时间
axios.defaults.timeout = 10000;

// 统一使用JSON格式
axios.defaults.headers.post["Content-Type"] = "application/json;charset=UTF-8";

// 请求拦截器
axios.interceptors.request.use(
  (config) => {
    // 这里可以添加token逻辑（使用Pinia）
    /*
    // 示例：
    // import { useAuthStore } from '@/stores/auth'
    // const authStore = useAuthStore();
    // if (authStore.token) {
    //   config.headers.Authorization = `Bearer ${authStore.token}`;
    // }
    */
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// 响应拦截器
axios.interceptors.response.use(
  (response) => {
    const res = response.data;
    if (res.hasOwnProperty("code")) {
      // 业务成功：code === 0
      if (res.code === 0 || res.code === 200) {
        // 直接返回实际数据（data 字段）
        return res; // 兼容没有 data 的情况
      } else {
        // 业务失败：code !== 0，弹出 msg 提示
        ElMessage.error(res.msg || "未知错误");
        // 可选：将错误返回到 catch
        return Promise.reject(new Error(res.msg || "请求失败"));
      }
    }

    return res;
  },
  // 服务器状态码不是200的情况
  (error) => {
    if (error.response?.status) {
      switch (error.response.status) {
        case 401:
          ElMessage.warning("未登录或权限已过期");
          break;
        case 403:
          ElMessage.warning("登录过期，请重新登录");
          /*
          // 清除token示例：
          // localStorage.removeItem("token");
          // authStore.clearToken(); 
          */
          setTimeout(() => {
            // 路由跳转示例
            /*
            // router.replace({
            //   path: "/login"
            // });
            */
          }, 1000);
          break;
        case 404:
          ElMessage.error("网络请求不存在");
          break;
        default:
          ElMessage.error(
            error.response.data?.message || "服务器开小差了，请稍后再试"
          );
      }
      return Promise.reject(error.response);
    } else {
      ElMessage.error("网络连接异常，请检查网络");
      return Promise.reject(error);
    }
  }
);

/**
 * get方法，对应get请求
 * @param {String} url [请求的url地址]
 * @param {Object} params [请求时携带的参数]
 */
export function get(url: string, params?: any) {
  return new Promise((resolve, reject) => {
    axios
      .get(url, { params })
      .then((res) => {
        resolve(res);
      })
      .catch((err) => {
        reject(err);
      });
  });
}

/**
 * post方法，对应post请求
 * @param {String} url [请求的url地址]
 * @param {Object} data [请求时携带的数据]
 */
export function post(url: string, data?: any) {
  return new Promise((resolve, reject) => {
    axios
      .post(url, data)
      .then((res) => {
        resolve(res);
      })
      .catch((err) => {
        reject(err);
      });
  });
}

/**
 * 流式请求方法
 * @param {String} url 请求的URL
 * @param {Object} data 请求数据
 * @param {AbortController} abortController 可选的AbortController实例
 * @param {Function} onData 处理数据流的回调函数
 * @param {Function} onComplete 请求完成时的回调函数
 * @param {Function} onError 错误处理回调函数
 */
export function streamPost(
  url: string,
  data: any,
  abortController?: AbortController,
  onData?: (chunk: string) => void,
  onComplete?: () => void,
  onError?: (error: any) => void
) {
  const controller = abortController || new AbortController();

  return fetch(`${baseURL}${url.startsWith("/") ? "" : "/"}${url}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: "text/event-stream",
      Connection: "keep-alive",
    },
    body: JSON.stringify(data),
    signal: controller.signal,
  })
    .then((response) => {
      if (!response.ok || !response.body) {
        throw new Error(`HTTP ${response.status}`);
      }

      return response.body.getReader();
    })
    .then((reader) => {
      const decoder = new TextDecoder("utf-8");

      function read() {
        return reader
          .read()
          .then(({ done, value }) => {
            if (done) {
              onComplete && onComplete();
              return;
            }

            const chunk = decoder.decode(value, { stream: true });
            onData && onData(chunk);

            return read();
          })
          .catch((error) => {
            onError && onError(error);
          });
      }

      return read();
    })
    .catch((error) => {
      onError && onError(error);
      throw error;
    });
}

/**
 * 获取表格数据的专用方法
 * @param {String} sessionId 会话ID
 */
export function getTableData(sessionId: string) {
  return post("/json_res", { session_id: sessionId }).then((response: any) => {
    return response.data || response; // 兼容不同的响应结构
  });
}

// 添加 request 方法以支持配置对象
export const request = (config: any) => {
  // 自动处理GET/DELETE等方法的参数位置
  const method = config.method?.toLowerCase();
  const paramMethods = ["get", "delete", "head", "options"];

  if (paramMethods.includes(method) && config.data) {
    config.params = config.data;
    delete config.data;
  }

  return axios(config);
};

export const stream = (url: string, params?: any) => {
  const fullUrl = baseURL
    ? `${baseURL}${url.startsWith("/") ? "" : "/"}${url}`
    : url;

  const queryString = QS.stringify(params);
  return new EventSource(`${fullUrl}${queryString ? `?${queryString}` : ""}`);
};

// 导出对象
export default {
  get,
  post,
  request,
  stream,
  streamPost,
  getTableData,
};
